💡 Задача: Загадочный Кэш

У тебя есть метод, который возвращает последовательность чисел, вычисляемую с задержкой (например, чтение из удалённого ресурса):

public static IEnumerable<int> GetSlowData()
{
    Console.WriteLine("Fetching data...");
    yield return 1;
    Thread.Sleep(1000);
    yield return 2;
    Thread.Sleep(1000);
    yield return 3;
}

Теперь тебе нужно реализовать метод ProcessData(), который:

Вызывает GetSlowData() один раз.

Проходит по данным дважды: сначала фильтрует только чётные, потом считает сумму всех.

Не должен повторно "запрашивать" данные (то есть Fetching data... должен выводиться один раз).

Не должен использовать ToList(), ToArray() или другие методы, загружающие всё в память явно.

🧠 Вопрос с подвохом: Как реализовать ProcessData()?
Напиши реализацию:

public static void ProcessData()
{
    // твой код здесь
}

🔎 Подсказка
Если ты просто используешь IEnumerable<int> и дважды к нему обращаешься — будет два запроса. Но есть один способ реализовать ленивое кэширование, не загружая всё в память сразу и не повторяя yield return.

Решение:

Если ты просто напишешь вот так:

```csharp
var data = GetSlowData();

var evens = data.Where(x => x % 2 == 0);
var sum = data.Sum();```

то GetSlowData() будет вызван дважды, потому что IEnumerable ленивый — и при каждом новом foreach начинается всё заново. Это видно по двойному выводу Fetching data....

🧠 Цель: пройтись по данным один раз, кэшируя элементы "на лету", и позволить другим перечислениям работать без повторного получения.
✅ Решение: Используем ленивый кеш — с помощью кастомного итератора

```csharp
public static void ProcessData()
{
var cached = new MemoizedEnumerable<int>(GetSlowData());

var evens = cached.Where(x => x % 2 == 0);
var sum = cached.Sum();

Console.WriteLine("Even numbers: " + string.Join(", ", evens));
Console.WriteLine("Sum: " + sum);
}```
А вот реализация ленивого кеширующего MemoizedEnumerable<T>:

```csharp
public class MemoizedEnumerable<T> : IEnumerable<T>
{
private readonly IEnumerator<T> _source;
private readonly List<T> _cache = new();
private bool _sourceFinished = false;

public MemoizedEnumerable(IEnumerable<T> source)
{
_source = source.GetEnumerator();
}

public IEnumerator<T> GetEnumerator()
{
int index = 0;
while (true)
{
if (index < _cache.Count)
{
yield return _cache[index];
}
else
{
if (_sourceFinished || !_source.MoveNext())
{
_sourceFinished = true;
yield break;
}

_cache.Add(_source.Current);
yield return _source.Current;
}
index++;
}
}

IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}```

🧪 Что происходит
MemoizedEnumerable запоминает каждый элемент один раз при первом проходе.

Следующие проходы используют кэш.

Fetching data... будет вызван только один раз.

💥 Подвох
Большинство подумает, что IEnumerable можно безопасно переиспользовать без сайд-эффектов. Но не тут-то было: без кэширования yield выполнится дважды. Многие Middle+ разработчики ошибаются именно тут.